%% @author 
%% @doc @todo Add description to maxteilsummeR.


-module(maxteilsummeRekMitIndizes).

%% ====================================================================
%% API functions
%% ====================================================================
-export([linkesRandMax/3, rechtesRandMax/3, maxTeilsummeRekursiv/1, teilen/1]).



%% ====================================================================
%% Internal functions
%% ====================================================================

deleteLast(L) -> lists:sublist(L,length(L)-1).

linkesRandMax(L, Von, Bis) -> linkesRandMax(L, 0, 0, Von, Bis + 1, {0,0}).
linkesRandMax([], BischerMax, _, _, _, VonBis) -> {BischerMax, VonBis};
linkesRandMax(L, BischerMax, BischerSum, Von, Bis, VonBis) -> case lists:sum(L) > BischerMax of
							  true -> linkesRandMax(deleteLast(L), lists:sum(L), BischerSum + lists:sum(L), Von, Bis - 1, {Von, Bis - 1});
				     		  false -> linkesRandMax(deleteLast(L), BischerMax, BischerSum + lists:sum(L), Von, Bis - 1, VonBis) end.
	
rechtesRandMax([H|T], Von, Bis) -> rechtesRandMax([H|T], 0, 0, Von, Bis, {0,0}).
rechtesRandMax([], BischerMax1, _, _, _, VonBis) -> {BischerMax1, VonBis};
rechtesRandMax([H|T], BischerMax1, BischerSum1, Von, Bis, VonBis) -> case lists:sum([H|T]) > BischerMax1 of
							  true -> rechtesRandMax(T, lists:sum([H|T]), BischerSum1 + lists:sum([H|T]), Von + 1, Bis, {Von, Bis});
				     		  false -> rechtesRandMax(T, BischerMax1, BischerSum1 + lists:sum([H|T]), Von + 1, Bis, VonBis) end.


maxTeilsummeRekursiv([]) -> {0, 0, 0};
maxTeilsummeRekursiv(L) -> maxTeilsummeRekursiv(L, 1, length(L)).
maxTeilsummeRekursiv(L, Von, Bis) -> if length(L) =:= 1 -> {max(hd(L),0), Von, Bis};
						true -> maxTeilsummeRekursiv(hd(teilen(L)), lists:flatten(tl(teilen(L))), Von, Bis) end.
maxTeilsummeRekursiv(H, T, Von, Bis) ->
		{Sum2, Von2, Bis2} = maxTeilsummeRekursiv(T, Von + length(H), Bis),
		{Sum1,Von1,Bis1} = maxTeilsummeRekursiv(H, Von, Bis - length(T)),
		{BischerMaxR, {VonR,_}} = rechtesRandMax(H, Von, Bis - length(T)),
		{BischerMaxL, {_,BisL}} = linkesRandMax(T, Von + length(H), Bis),
		SumM = BischerMaxR + BischerMaxL,
	    if 
		   (Sum1 >= Sum2) and (Sum1 >= SumM) -> SumErg = Sum1, VonErg = Von1, BisErg = Bis1, io:fwrite("L");
		   (Sum2 >= Sum1) and (Sum2 >= SumM) -> SumErg = Sum2, VonErg = Von2, BisErg = Bis2, io:fwrite("R");
		   (SumM >= Sum2) and (SumM >= Sum1) -> SumErg = SumM, VonErg = VonR, BisErg = BisL, io:fwrite("S")
		end,
		{SumErg,VonErg,BisErg}.
							
teilen(L) -> tuple_to_list(lists:split(round(length(L)/2), L)).				



